/**
 * 增强版灯光模式管理服务
 * 用于管理灯光模式的状态和切换
 */

const storageService = require('./storage')
const lightModeService = require('./light_mode')

// 灯光模式类型常量
const LIGHT_MODE_TYPES = {
  // 自动模式
  AUTO: 'auto',
  // 手动模式
  MANUAL: 'manual',
}

// 当前灯光模式常量
const CURRENT_LIGHT_MODES = {
  // 手动快捷模式
  MANUAL_SHORTCUT: 'manual_shortcut',
  // 手动玩家模式
  MANUAL_PLAYER: 'manual_player',
}

// 快捷模式的模式代码到索引映射
const MODE_CODE_TO_INDEX = {
  m0: 0, // SPS模式
  m1: 1, // LPS模式
  m2: 2, // SPS\LPS混养
  m3: 3, // 辣椒榕模式
  m4: 4, // 清爽模式
  m5: 5, // 淡雅模式
  m6: 6, // 美艳模式
}

// 直接 require JSON 文件，它会自动被解析为 JS 对象
const SHORTCUT_MODE_RGBW_VALUES = require('./shortcut_mode_rgbw_data.js');

/**
 * 检查是否为手动模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否为手动模式
 */
function isManualMode(id, isGroup = false, deviceType) {
  return storageService.getLightModeState(id) === LIGHT_MODE_TYPES.MANUAL
}

/**
 * 检查是否为自动模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否为自动模式
 */
function isAutoMode(id, isGroup = false, deviceType) {
  return storageService.getLightModeState(id) === LIGHT_MODE_TYPES.AUTO
}

/**
 * 获取当前灯光模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {string} 当前灯光模式，默认为手动快捷模式
 */
function getCurrentLightMode(id, isGroup = false, deviceType) {
  return lightModeService.getCurrentLightMode(id, isGroup, deviceType)
}

/**
 * 检查是否为手动快捷模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否为手动快捷模式
 */
function isManualShortcutMode(id, isGroup = false, deviceType) {
  return (
    isManualMode(id, isGroup, deviceType) &&
    getCurrentLightMode(id, isGroup, deviceType) === CURRENT_LIGHT_MODES.MANUAL_SHORTCUT
  )
}

/**
 * 检查是否为手动玩家模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否为手动玩家模式
 */
function isManualPlayerMode(id, isGroup = false, deviceType) {
  return (
    isManualMode(id, isGroup, deviceType) &&
    getCurrentLightMode(id, isGroup, deviceType) === CURRENT_LIGHT_MODES.MANUAL_PLAYER
  )
}

/**
 * 设置为手动模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function setManualMode(id, isGroup = false, deviceType) {
  storageService.saveLightModeState(id, LIGHT_MODE_TYPES.MANUAL, isGroup, deviceType)

  if (isGroup) {
    const groups = storageService.getGroups()
    const groupIndex = groups.findIndex(g => g.id === id)
    if (groupIndex !== -1) {
      groups[groupIndex].startTime = '--:--'
      groups[groupIndex].endTime = '--:--'
      storageService.saveGroups(groups)
    }
  } else {
    const devices = storageService.getDevices()
    const deviceIndex = devices.findIndex(d => d.id === id)
    if (deviceIndex !== -1) {
      devices[deviceIndex].startTime = '--:--'
      devices[deviceIndex].endTime = '--:--'
      storageService.saveDevices(devices)
    }
  }

  console.log(`已切换到手动模式 (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)
}

/**
 * 设置为手动快捷模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function setManualShortcutMode(id, isGroup = false, deviceType) {
  storageService.saveLightModeState(id, LIGHT_MODE_TYPES.MANUAL, isGroup, deviceType);

  lightModeService.saveCurrentLightMode(id, CURRENT_LIGHT_MODES.MANUAL_SHORTCUT, isGroup, deviceType);

  // 使用 storageService 保存模式切换状态
  // 注意：这里的 key 生成方式 `${id}_mode_switch` 可能不符合 storageService 中 getStorageKey 的规范
  // 为了保持与现有逻辑一致（如果这个 key 的确是这样直接使用的），我们暂时直接使用它
  // 理想情况下，也应该通过 getStorageKey 或为其定义新的 STORAGE_KEYS
  const modeSwitchKey = `${id}_mode_switch`;
  storageService.saveData(modeSwitchKey, 'shortcut');

  if (isGroup) {
    const groups = storageService.getGroups()
    const groupIndex = groups.findIndex(g => g.id === id)
    if (groupIndex !== -1) {
      groups[groupIndex].startTime = '--:--'
      groups[groupIndex].endTime = '--:--'
      storageService.saveGroups(groups)
    }
  } else {
    const devices = storageService.getDevices()
    const deviceIndex = devices.findIndex(d => d.id === id)
    if (deviceIndex !== -1) {
      devices[deviceIndex].startTime = '--:--'
      devices[deviceIndex].endTime = '--:--'
      storageService.saveDevices(devices)
    }
  }

  console.log(`已切换到手动快捷模式 (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)

  _disablePlayerModeTasks(id, isGroup, deviceType)

  _disableAdvancedModeCurves(id, isGroup, deviceType)
}

/**
 * 设置为手动玩家模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function setManualPlayerMode(id, isGroup = false, deviceType) {
  storageService.saveLightModeState(id, LIGHT_MODE_TYPES.MANUAL, isGroup, deviceType);

  lightModeService.saveCurrentLightMode(id, CURRENT_LIGHT_MODES.MANUAL_PLAYER, isGroup, deviceType);

  // 使用 storageService 保存模式切换状态
  const modeSwitchKey = `${id}_mode_switch`;
  storageService.saveData(modeSwitchKey, 'player');

  if (isGroup) {
    const groups = storageService.getGroups()
    const groupIndex = groups.findIndex(g => g.id === id)
    if (groupIndex !== -1) {
      groups[groupIndex].startTime = '--:--'
      groups[groupIndex].endTime = '--:--'
      storageService.saveGroups(groups)
    }
  } else {
    const devices = storageService.getDevices()
    const deviceIndex = devices.findIndex(d => d.id === id)
    if (deviceIndex !== -1) {
      devices[deviceIndex].startTime = '--:--'
      devices[deviceIndex].endTime = '--:--'
      storageService.saveDevices(devices)
    }
  }

  console.log(`已切换到手动玩家模式 (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)

  _disableShortcutModeTasks(id, isGroup, deviceType)

  _disableAdvancedModeCurves(id, isGroup, deviceType)
}

/**
 * 设置为自动模式
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function setAutoMode(id, isGroup = false, deviceType) {
  console.log(`尝试切换到自动模式 (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)
  const hasTask = _hasEnabledTask(id, isGroup, deviceType)
  const hasCurve = _hasEnabledCurve(id, isGroup, deviceType)

  console.log(`检查结果: hasTask=${hasTask}, hasCurve=${hasCurve}`)

  storageService.saveLightModeState(id, LIGHT_MODE_TYPES.AUTO, isGroup, deviceType)

  // 使用 storageService 保存模式切换状态为 null
  const modeSwitchKey = `${id}_mode_switch`;
  storageService.saveData(modeSwitchKey, null);

  console.log('已切换到自动模式')
}

/**
 * 检查是否有启用的自动模式任务 (快捷或玩家)
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否有启用的任务
 */
function _hasEnabledTask(id, isGroup = false, deviceType) {
  const shortcutModeData = storageService.getShortcutModeData(id, isGroup, deviceType)
  if (shortcutModeData && shortcutModeData.tasks && shortcutModeData.tasks.some(task => task.enabled)) {
    return true
  }
  const playerModeData = storageService.getPlayerModeData(id, isGroup, deviceType)
  if (playerModeData && playerModeData.tasks && playerModeData.tasks.some(task => task.enabled)) {
    return true
  }
  return false
}

/**
 * 检查是否有启用的高级模式曲线
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 * @returns {boolean} 是否有启用的曲线
 */
function _hasEnabledCurve(id, isGroup = false, deviceType) {
  const advancedModeData = storageService.getAdvancedModeData(id, isGroup, deviceType)
  return advancedModeData && advancedModeData.curves && advancedModeData.curves.some(curve => curve.enabled)
}

/**
 * 重置手动模式的RGBW控制状态 (内部函数)
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function _resetRGBWControls(id, isGroup = false, deviceType) {
  // 1. 重置快捷模式的亮度设置
  const defaultShortcutSetting = Array.from({ length: 7 }).map(() => ({ brightness: 0 }));
  storageService.saveModeSettingData(id, defaultShortcutSetting, isGroup, deviceType)

  // 2. 重置玩家模式的当前设置
  const defaultPlayerSetting = { r: 0, g: 0, b: 0, w: 0, p: 0, u: 0, totalBrightness: 0 }
  const currentPlayerModeData = storageService.getPlayerModeData(id, isGroup, deviceType) || {}
  storageService.savePlayerModeData(id, { ...currentPlayerModeData, currentSetting: defaultPlayerSetting }, isGroup, deviceType)

  // 3. 获取基础长度值（即使值为0时也保留的长度）
  const baseLength = getBaseLength();

  // 4. 直接重置存储中设备/编组对象的 RGBW 值 (恢复此逻辑以更新首页卡片)
  const entities = isGroup ? storageService.getGroups() : storageService.getDevices()
  
  // 检查ID是否有效
  if (!id) {
    console.warn('_resetRGBWControls: ID无效，无法重置 RGBWPUV 值')
    return
  }

  // 检查是否以group_开头
  const hasGroupPrefix = typeof id === 'string' && id.startsWith('group_')
  // 如果传入的ID有group_前缀，确保isGroup标志为true
  const actualIsGroup = hasGroupPrefix || isGroup
  // 如果是编组且ID有前缀，获取不带前缀的ID部分用于查找
  const searchId = actualIsGroup && hasGroupPrefix ? id : id
  
  const entityIndex = entities.findIndex(e => e.id === searchId)

  if (entityIndex !== -1) {
    // 确保值为0，但UI展示时会保留基础长度
    entities[entityIndex].red = 0
    entities[entityIndex].green = 0
    entities[entityIndex].blue = 0
    entities[entityIndex].white = 0
    entities[entityIndex].purple = 0
    entities[entityIndex].uv = 0
    entities[entityIndex].totalSwitch = false // 确保总开关也关闭

    // 保存更新后的实体列表
    if (actualIsGroup) {
      storageService.saveGroups(entities)
    } else {
      storageService.saveDevices(entities)
    }
    console.log(`Homepage Reset: 重置设备/编组 RGBWPUV 值 (ID: ${id}, isGroup: ${actualIsGroup})，UI展示时将保留 ${baseLength}% 基础长度`)
  } else {
    // 改为输出调试信息，而不是警告
    console.log(`_resetRGBWControls: 未找到实体 (ID: ${id}, isGroup: ${actualIsGroup})，跳过重置 RGBWPUV 值操作`)
  }

  console.log(`已重置手动模式控制状态 (ID: ${id}, isGroup: ${actualIsGroup}, deviceType: ${deviceType})`)
}

/**
 * 禁用所有快捷模式任务
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function _disableShortcutModeTasks(id, isGroup = false, deviceType) {
  const shortcutModeData = storageService.getShortcutModeData(id, isGroup, deviceType)
  if (!shortcutModeData) return // 如果没有快捷模式数据，直接返回

  let timerTasks = shortcutModeData.timerTasks || []
  let curveTasks = shortcutModeData.curveTasks || []
  let hasChanges = false

  // 禁用定时任务
  timerTasks = timerTasks.map(task => {
    if (task.enabled) {
      hasChanges = true
      return { ...task, enabled: false }
    }
    return task
  })

  // 禁用曲线任务
  curveTasks = curveTasks.map(task => {
    if (task.enabled) {
      hasChanges = true
      return { ...task, enabled: false }
    }
    return task
  })

  if (hasChanges) {
    const updatedData = {
      ...shortcutModeData,
      timerTasks,
      curveTasks,
    }
    storageService.saveShortcutModeData(id, updatedData, isGroup, deviceType)
    console.log(`已禁用快捷模式任务 (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)
  }

  _disableAdvancedModeCurves(id, isGroup, deviceType)
}

/**
 * 禁用所有玩家模式任务 (包括预设)
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function _disablePlayerModeTasks(id, isGroup = false, deviceType) {
  // 玩家模式和快捷模式共享定时任务，所以调用相同的禁用方法
  _disableShortcutModeTasks(id, isGroup, deviceType)
}

/**
 * 私有方法：禁用高阶模式相关的曲线
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function _disableAdvancedModeCurves(id, isGroup = false, deviceType) {
  if (!deviceType) {
    console.error('_disableAdvancedModeCurves: 缺少 deviceType 参数')
    return
  }
  const advancedModeData = storageService.getAdvancedModeData(id, isGroup, deviceType)
  let curves = advancedModeData.curves || []
  let hasChanges = false

  // 禁用所有曲线
  curves = curves.map(curve => {
    if (curve.enabled) {
      hasChanges = true
      return { ...curve, enabled: false }
    }
    return curve
  })

  // 如果有曲线状态变更，保存更新后的数据
  if (hasChanges) {
    advancedModeData.curves = curves
    storageService.saveAdvancedModeData(id, advancedModeData, isGroup, deviceType)
    console.log(`已禁用高阶模式曲线 (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)
  }
}

/**
 * 更新设备或编组的总开关状态
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {boolean} state - 总开关状态
 */
function updateTotalSwitchState(id, isGroup = false, state) {
  lightModeService.updateTotalSwitchState(id, isGroup, state)
}

/**
 * 将MQTT RGBW值转换为百分比值
 * @param {number} value - MQTT RGBW值（0-1023）
 * @returns {number} 百分比值（0-100）
 */
function convertToPercentage(value) {
  // 确保value在有效范围内
  const validValue = Math.max(0, Math.min(1023, value))
  // 将0-1023范围转换为0-100
  return Math.round((validValue / 1023) * 100)
}

/**
 * 获取基础长度百分比（当值为0时使用）
 * @returns {number} 基础长度百分比
 */
function getBaseLength() {
  return 5 // 当值为0时使用的基础长度（5%）
}

/**
 * 将快捷模式或玩家模式的灯光设置数据合并保存到手动模式RGBW缓存
 * 只保存最新的一条数据
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {Object} rgbwValues - RGBW值对象
 * @param {number} rgbwValues.red - 红色值（百分比）
 * @param {number} rgbwValues.green - 绿色值（百分比）
 * @param {number} rgbwValues.blue - 蓝色值（百分比）
 * @param {number} rgbwValues.white - 白色值（百分比）
 * @param {string} deviceType - 设备类型
 */
function updateManualModeRgbwCache(id, isGroup = false, rgbwValues, deviceType) {
  try {
    // 检查ID是否以group_开头，如果是则确保isGroup为true
    const hasGroupPrefix = typeof id === 'string' && id.startsWith('group_')
    const actualIsGroup = hasGroupPrefix || isGroup

    // 确保是手动模式
    if (!isManualMode(id, actualIsGroup, deviceType)) {
      console.log(`设备/编组[${id}]不是手动模式，不更新RGBW缓存`)
      return
    }

    // 从页面获取当前缓存
    const pages = getCurrentPages()
    if (!pages || pages.length === 0) {
      console.log('没有可用的页面实例，尝试通过缓存更新数据')
      // 尝试从本地缓存获取或创建新的缓存
      let manualModeRgbwCache = wx.getStorageSync('manualModeRgbwCache') || {}
      if (typeof manualModeRgbwCache === 'string') {
        try {
          manualModeRgbwCache = JSON.parse(manualModeRgbwCache)
        } catch (e) {
          manualModeRgbwCache = {}
        }
      }

      // 缓存键
      const cacheKey = actualIsGroup ? `group_${id}` : id

      // 更新缓存，添加所有8个通道
      manualModeRgbwCache[cacheKey] = {
        red: rgbwValues.red || 0,
        green: rgbwValues.green || 0,
        blue: rgbwValues.blue || 0,
        white: rgbwValues.white || 0,
        lightBlue: rgbwValues.lightBlue || 0,
        royalBlue: rgbwValues.royalBlue || 0,
        purple: rgbwValues.purple || 0,
        uv: rgbwValues.uv || 0
      }

      // 保存回缓存
      wx.setStorageSync('manualModeRgbwCache', manualModeRgbwCache)
      console.log(`已通过本地缓存更新手动模式RGBW缓存，设备/编组[${id}]`)
      return
    }

    // 获取当前页面
    const currentPage = pages[pages.length - 1]
    if (!currentPage) {
      console.log('无法获取当前页面实例，尝试通过缓存更新数据')
      return
    }

    // 如果页面中没有manualModeRgbwCache，初始化一个
    if (!currentPage.data || !currentPage.data.manualModeRgbwCache) {
      console.log('当前页面无manualModeRgbwCache数据，尝试初始化')

      // 尝试从本地缓存获取
      let manualModeRgbwCache = wx.getStorageSync('manualModeRgbwCache') || {}
      if (typeof manualModeRgbwCache === 'string') {
        try {
          manualModeRgbwCache = JSON.parse(manualModeRgbwCache)
        } catch (e) {
          manualModeRgbwCache = {}
        }
      }

      // 初始化页面数据
      currentPage.setData({
        manualModeRgbwCache: manualModeRgbwCache,
      })
    }

    // 复制缓存
    const manualModeRgbwCache = { ...(currentPage.data.manualModeRgbwCache || {}) }

    // 缓存键
    const cacheKey = actualIsGroup ? `group_${id}` : id

    // 更新缓存，添加所有8个通道
    manualModeRgbwCache[cacheKey] = {
      red: rgbwValues.red || 0,
      green: rgbwValues.green || 0,
      blue: rgbwValues.blue || 0,
      white: rgbwValues.white || 0,
      lightBlue: rgbwValues.lightBlue || 0,
      royalBlue: rgbwValues.royalBlue || 0,
      purple: rgbwValues.purple || 0,
      uv: rgbwValues.uv || 0
    }

    console.log(`已更新手动模式RGBW缓存，设备/编组[${id}]，值:`, manualModeRgbwCache[cacheKey])

    // 更新页面数据
    currentPage.setData(
      {
        manualModeRgbwCache: manualModeRgbwCache,
      },
      () => {
        // 同时保存到本地缓存，确保数据持久化
        wx.setStorageSync('manualModeRgbwCache', manualModeRgbwCache)
      }
    )
  } catch (error) {
    console.error('更新手动模式RGBW缓存时出错:', error)
    // 出错时尝试直接保存到本地缓存
    try {
      let manualModeRgbwCache = wx.getStorageSync('manualModeRgbwCache') || {}
      if (typeof manualModeRgbwCache === 'string') {
        manualModeRgbwCache = JSON.parse(manualModeRgbwCache)
      }

      const cacheKey = isGroup ? `group_${id}` : id
      manualModeRgbwCache[cacheKey] = {
        red: rgbwValues.red || 0,
        green: rgbwValues.green || 0,
        blue: rgbwValues.blue || 0,
        white: rgbwValues.white || 0,
        lightBlue: rgbwValues.lightBlue || 0,
        royalBlue: rgbwValues.royalBlue || 0,
        purple: rgbwValues.purple || 0,
        uv: rgbwValues.uv || 0
      }

      wx.setStorageSync('manualModeRgbwCache', manualModeRgbwCache)
      console.log('通过本地缓存回退方式保存了RGBW缓存')
    } catch (e) {
      console.error('保存RGBW缓存到本地存储也失败:', e)
    }
  }
}

/**
 * 根据快捷模式亮度更新总开关状态和灯光条显示
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {number} brightness - 亮度值
 * @param {number} modeIndex - 模式索引（0-6）
 * @param {string} deviceType - 设备类型
 */
function updateByShortcutMode(id, isGroup = false, brightness, modeIndex, deviceType) {
  // 确保 RGBW 数据已加载 (现在是同步 require，所以肯定已加载，但保留检查以防万一或未来改动)
  if (!SHORTCUT_MODE_RGBW_VALUES) {
    console.error('[light_mode_enhanced] RGBW values not loaded, cannot update by shortcut mode.');
    return { success: false, error: 'RGBW data not available' };
  }

  const modeRgbwValues = SHORTCUT_MODE_RGBW_VALUES[modeIndex];

  // 检查ID是否以group_开头，如果是则确保isGroup为true
  const hasGroupPrefix = typeof id === 'string' && id.startsWith('group_')
  const actualIsGroup = hasGroupPrefix || isGroup

  if (isManualShortcutMode(id, actualIsGroup, deviceType)) {
    // 总开关状态根据亮度是否大于0来决定
    const totalSwitchState = brightness > 0
    updateTotalSwitchState(id, actualIsGroup, totalSwitchState)

    console.log(
      `手动快捷模式: 更新总开关状态为 ${totalSwitchState ? '开启' : '关闭'} (ID: ${id}, isGroup: ${actualIsGroup})`
    )

    // 获取对应模式索引和亮度的RGBW值
    if (modeIndex >= 0 && modeIndex <= 6 && modeRgbwValues) {
      const rgbwValues = modeRgbwValues[brightness] || [0, 0, 0, 0]

      // 更新设备或编组的灯光值
      const entities = actualIsGroup ? storageService.getGroups() : storageService.getDevices()
      const entityIndex = entities.findIndex(e => e.id === id)

      if (entityIndex !== -1) {
        // 将MQTT值转换为百分比
        const percentages = {
          red: brightness > 0 ? convertToPercentage(rgbwValues[0]) : 0,
          green: brightness > 0 ? convertToPercentage(rgbwValues[1]) : 0,
          blue: brightness > 0 ? convertToPercentage(rgbwValues[2]) : 0,
          white: brightness > 0 ? convertToPercentage(rgbwValues[3]) : 0,
        }

        // 更新实体的RGBW值
        entities[entityIndex].red = percentages.red
        entities[entityIndex].green = percentages.green
        entities[entityIndex].blue = percentages.blue
        entities[entityIndex].white = percentages.white

        // 保存更新后的实体列表
        if (actualIsGroup) {
          storageService.saveGroups(entities)

          // 如果是编组，同步RGBW值到编组内的所有设备
          const group = entities[entityIndex]
          if (group && Array.isArray(group.deviceIds) && group.deviceIds.length > 0) {
            const devices = storageService.getDevices()
            let devicesChanged = false

            group.deviceIds.forEach(deviceId => {
              const deviceIndex = devices.findIndex(d => d.id === deviceId)
              if (deviceIndex !== -1) {
                // 同步RGBW值到设备
                devices[deviceIndex].red = percentages.red
                devices[deviceIndex].green = percentages.green
                devices[deviceIndex].blue = percentages.blue
                devices[deviceIndex].white = percentages.white
                devicesChanged = true
              }
            })

            if (devicesChanged) {
              storageService.saveDevices(devices)
              console.log(`手动快捷模式: 已同步编组[${id}]的RGBW值到所有设备`)
            }
          }
        } else {
          storageService.saveDevices(entities)

          // 如果是设备，检查它是否属于某个编组，如果是则同步到编组
          const device = entities[entityIndex]
          if (device && device.inGroup && device.groupId) {
            const groups = storageService.getGroups()
            const groupIndex = groups.findIndex(g => g.id === device.groupId)
            if (groupIndex !== -1) {
              // 同步RGBW值到编组
              groups[groupIndex].red = percentages.red
              groups[groupIndex].green = percentages.green
              groups[groupIndex].blue = percentages.blue
              groups[groupIndex].white = percentages.white
              storageService.saveGroups(groups)
              console.log(`手动快捷模式: 已同步设备[${id}]的RGBW值到编组[${device.groupId}]`)
            }
          }
        }

        // 更新手动模式RGBW缓存
        updateManualModeRgbwCache(id, actualIsGroup, percentages, deviceType)

        console.log(
          `手动快捷模式: 更新灯光值 (ID: ${id}, RGBW: ${percentages.red}%, ${percentages.green}%, ${percentages.blue}%, ${percentages.white}%)`
        )
      }
    }
  }
}

/**
 * 根据快捷模式亮度更新总开关状态
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {number} brightness - 亮度值
 * @param {string} deviceType - 设备类型
 */
function updateTotalSwitchByShortcutBrightness(id, isGroup = false, brightness, deviceType) {
  console.log(
    `updateTotalSwitchByShortcutBrightness called for ${isGroup ? 'group' : 'device'} ${id}, brightness: ${brightness}, deviceType: ${deviceType}`
  )
  // 确保 deviceType 有效
  if (!deviceType) {
    console.error(
      'updateTotalSwitchByShortcutBrightness: 必须提供 deviceType 参数才能确定模式状态！'
    )
    return
  }
  // 检查当前是否真的是手动快捷模式
  // 传递 deviceType
  if (isManualShortcutMode(id, isGroup, deviceType)) {
    // 亮度大于0，则总开关为开；亮度为0，则总开关为关
    const newState = brightness > 0
    updateTotalSwitchState(id, isGroup, newState)
    console.log(
      `快捷模式更新总开关状态: ${newState ? '开' : '关'} (ID: ${id}, isGroup: ${isGroup})`
    )
  } else {
    console.log(
      `updateTotalSwitchByShortcutBrightness: 当前不是手动快捷模式，不更新总开关 (ID: ${id}, isGroup: ${isGroup})`
    )
  }
}

/**
 * 根据玩家模式RGBW值更新总开关状态和灯光条显示
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {Object} rgbwValues - RGBW值对象
 * @param {number} rgbwValues.redValue - 红色值（百分比）
 * @param {number} rgbwValues.greenValue - 绿色值（百分比）
 * @param {number} rgbwValues.blueValue - 蓝色值（百分比）
 * @param {number} rgbwValues.whiteValue - 白色值（百分比）
 * @param {string} deviceType - 设备类型
 */
function updateByPlayerMode(id, isGroup = false, rgbwValues, deviceType) {
  // 检查ID是否以group_开头，如果是则确保isGroup为true
  const hasGroupPrefix = typeof id === 'string' && id.startsWith('group_')
  const actualIsGroup = hasGroupPrefix || isGroup

  if (isManualPlayerMode(id, actualIsGroup, deviceType)) {
    // 判断是否所有RGBW值都为0
    const allZero =
      rgbwValues.redValue === 0 &&
      rgbwValues.greenValue === 0 &&
      rgbwValues.blueValue === 0 &&
      rgbwValues.whiteValue === 0

    // 总开关状态根据是否所有RGBW值都为0来决定
    const totalSwitchState = !allZero
    updateTotalSwitchState(id, actualIsGroup, totalSwitchState)

    console.log(
      `手动玩家模式: 更新总开关状态为 ${totalSwitchState ? '开启' : '关闭'} (ID: ${id}, isGroup: ${actualIsGroup})`
    )

    // 获取基础长度（当值为0时使用）
    const baseLength = getBaseLength()

    // 更新设备或编组的灯光值
    const entities = actualIsGroup ? storageService.getGroups() : storageService.getDevices()
    const entityIndex = entities.findIndex(e => e.id === id)

    if (entityIndex !== -1) {
      // 更新实体的RGBW值，确保为0时使用基础长度
      entities[entityIndex].red = rgbwValues.redValue || 0
      entities[entityIndex].green = rgbwValues.greenValue || 0
      entities[entityIndex].blue = rgbwValues.blueValue || 0
      entities[entityIndex].white = rgbwValues.whiteValue || 0
      entities[entityIndex].lightBlue = rgbwValues.lightBlueValue || 0
      entities[entityIndex].royalBlue = rgbwValues.royalBlueValue || 0
      entities[entityIndex].purple = rgbwValues.purpleValue || 0
      entities[entityIndex].uv = rgbwValues.uvValue || 0

      // 保存更新后的实体列表
      if (actualIsGroup) {
        storageService.saveGroups(entities)

        // 如果是编组，同步RGBW值到编组内的所有设备
        const group = entities[entityIndex]
        if (group && Array.isArray(group.deviceIds) && group.deviceIds.length > 0) {
          const devices = storageService.getDevices()
          let devicesChanged = false

          group.deviceIds.forEach(deviceId => {
            const deviceIndex = devices.findIndex(d => d.id === deviceId)
            if (deviceIndex !== -1) {
              // 同步RGBW值到设备
              devices[deviceIndex].red = rgbwValues.redValue || 0
              devices[deviceIndex].green = rgbwValues.greenValue || 0
              devices[deviceIndex].blue = rgbwValues.blueValue || 0
              devices[deviceIndex].white = rgbwValues.whiteValue || 0
              devices[deviceIndex].lightBlue = rgbwValues.lightBlueValue || 0
              devices[deviceIndex].royalBlue = rgbwValues.royalBlueValue || 0
              devices[deviceIndex].purple = rgbwValues.purpleValue || 0
              devices[deviceIndex].uv = rgbwValues.uvValue || 0
              devicesChanged = true
            }
          })

          if (devicesChanged) {
            storageService.saveDevices(devices)
            console.log(`手动玩家模式: 已同步编组[${id}]的RGBW值到所有设备`)
          }
        }
      } else {
        storageService.saveDevices(entities)

        // 如果是设备，检查它是否属于某个编组，如果是则同步到编组
        const device = entities[entityIndex]
        if (device && device.inGroup && device.groupId) {
          const groups = storageService.getGroups()
          const groupIndex = groups.findIndex(g => g.id === device.groupId)
          if (groupIndex !== -1) {
            // 同步RGBW值到编组
            groups[groupIndex].red = rgbwValues.redValue || 0
            groups[groupIndex].green = rgbwValues.greenValue || 0
            groups[groupIndex].blue = rgbwValues.blueValue || 0
            groups[groupIndex].white = rgbwValues.whiteValue || 0
            groups[groupIndex].lightBlue = rgbwValues.lightBlueValue || 0
            groups[groupIndex].royalBlue = rgbwValues.royalBlueValue || 0
            groups[groupIndex].purple = rgbwValues.purpleValue || 0
            groups[groupIndex].uv = rgbwValues.uvValue || 0
            storageService.saveGroups(groups)
            console.log(`手动玩家模式: 已同步设备[${id}]的RGBW值到编组[${device.groupId}]`)
          }
        }
      }

      // 更新手动模式RGBW缓存 - 将玩家模式的RGBW值格式转换为统一格式
      updateManualModeRgbwCache(id, actualIsGroup, {
        red: rgbwValues.redValue || 0,
        green: rgbwValues.greenValue || 0,
        blue: rgbwValues.blueValue || 0,
        white: rgbwValues.whiteValue || 0,
        lightBlue: rgbwValues.lightBlueValue || 0,
        royalBlue: rgbwValues.royalBlueValue || 0,
        purple: rgbwValues.purpleValue || 0,
        uv: rgbwValues.uvValue || 0
      }, deviceType)

      console.log(
        `手动玩家模式: 更新灯光值 (ID: ${id}, RGBWPLR: ${rgbwValues.redValue || 0}%, ${rgbwValues.greenValue || 0}%, ${rgbwValues.blueValue || 0}%, ${rgbwValues.whiteValue || 0}%, ${rgbwValues.purpleValue || 0}%, ${rgbwValues.lightBlueValue || 0}%, ${rgbwValues.royalBlueValue || 0}%, ${rgbwValues.uvValue || 0}%)`
      )
    }
  }
}

/**
 * 根据玩家模式RGBW值更新总开关状态
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {Object} rgbwValues - RGBW值对象
 * @param {number} rgbwValues.redValue - 红色值
 * @param {number} rgbwValues.greenValue - 绿色值
 * @param {number} rgbwValues.blueValue - 蓝色值
 * @param {number} rgbwValues.whiteValue - 白色值
 * @param {string} deviceType - 设备类型
 */
function updateTotalSwitchByPlayerRgbw(id, isGroup = false, rgbwValues, deviceType) {
  // 检查ID是否以group_开头，如果是则确保isGroup为true
  const hasGroupPrefix = typeof id === 'string' && id.startsWith('group_')
  const actualIsGroup = hasGroupPrefix || isGroup

  if (isManualPlayerMode(id, actualIsGroup, deviceType)) {
    const allZero =
      rgbwValues.redValue === 0 &&
      rgbwValues.greenValue === 0 &&
      rgbwValues.blueValue === 0 &&
      rgbwValues.whiteValue === 0 &&
      (rgbwValues.lightBlueValue === 0 || rgbwValues.lightBlueValue === undefined) &&
      (rgbwValues.royalBlueValue === 0 || rgbwValues.royalBlueValue === undefined) &&
      (rgbwValues.purpleValue === 0 || rgbwValues.purpleValue === undefined) &&
      (rgbwValues.uvValue === 0 || rgbwValues.uvValue === undefined)

    const totalSwitchState = !allZero
    updateTotalSwitchState(id, actualIsGroup, totalSwitchState)
    console.log(
      `手动玩家模式: 更新总开关状态为 ${totalSwitchState ? '开启' : '关闭'} (ID: ${id}, isGroup: ${actualIsGroup})`
    )
  }
}

/**
 * 处理从快捷模式页面MQTT获取的灯光数据
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} modeCode - 模式代码 (m0-m6)
 * @param {number} brightness - 亮度档位 (0-10)
 * @param {Object} mqttRgbw - MQTT RGBW值
 * @param {number} mqttRgbw.R - 红色通道值 (0-1023)
 * @param {number} mqttRgbw.G - 绿色通道值 (0-1023)
 * @param {number} mqttRgbw.B - 蓝色通道值 (0-1023)
 * @param {number} mqttRgbw.W - 白色通道值 (0-1023)
 * @param {string} deviceType - 设备类型
 */
function handleShortcutModeMqttData(id, isGroup, modeCode, brightness, mqttRgbw, deviceType) {
  if (isManualShortcutMode(id, isGroup, deviceType)) {
    // 将模式代码转换为索引
    const modeIndex = MODE_CODE_TO_INDEX[modeCode] !== undefined ? MODE_CODE_TO_INDEX[modeCode] : 0

    // 更新灯光状态和总开关
    updateByShortcutMode(id, isGroup, brightness, modeIndex, deviceType)
  }
}

/**
 * 处理从玩家模式页面MQTT获取的灯光数据
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {Object} mqttRgbw - MQTT RGBW值
 * @param {number} mqttRgbw.R - 红色通道值 (0-1023)
 * @param {number} mqttRgbw.G - 绿色通道值 (0-1023)
 * @param {number} mqttRgbw.B - 蓝色通道值 (0-1023)
 * @param {number} mqttRgbw.W - 白色通道值 (0-1023)
 * @param {string} deviceType - 设备类型
 */
function handlePlayerModeMqttData(id, isGroup, mqttRgbw, deviceType) {
  if (isManualPlayerMode(id, isGroup, deviceType)) {
    // 将MQTT值转换为百分比
    const rgbwValues = {
      redValue: convertToPercentage(mqttRgbw.R),
      greenValue: convertToPercentage(mqttRgbw.G),
      blueValue: convertToPercentage(mqttRgbw.B),
      whiteValue: convertToPercentage(mqttRgbw.W),
      lightBlueValue: convertToPercentage(mqttRgbw.LB),
      royalBlueValue: convertToPercentage(mqttRgbw.RB),
      purpleValue: convertToPercentage(mqttRgbw.V),
      uvValue: convertToPercentage(mqttRgbw.UV)
    }

    // 更新灯光状态和总开关
    updateByPlayerMode(id, isGroup, rgbwValues, deviceType)
  }
}

/**
 * 处理长按行程设置按钮开启手动模式的情况
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} targetMode - 目标模式 (manual_shortcut/manual_player)
 * @param {string} deviceType - 设备类型
 */
function handleManualModeActivation(id, isGroup, targetMode, deviceType) {
  // 设置为手动模式
  storageService.saveLightModeState(id, LIGHT_MODE_TYPES.MANUAL, isGroup, deviceType)

  // 根据目标模式设置当前灯光模式
  if (targetMode === CURRENT_LIGHT_MODES.MANUAL_SHORTCUT) {
    lightModeService.saveCurrentLightMode(id, CURRENT_LIGHT_MODES.MANUAL_SHORTCUT, isGroup)

    // 获取当前快捷模式的设置
    const shortcutData = storageService.getShortcutModeData(id, isGroup, deviceType)
    if (
      shortcutData &&
      shortcutData.currentMode !== undefined &&
      shortcutData.brightness !== undefined
    ) {
      // 更新灯光控制条显示和总开关状态
      updateByShortcutMode(id, isGroup, shortcutData.brightness, shortcutData.currentMode, deviceType)
    }
  } else if (targetMode === CURRENT_LIGHT_MODES.MANUAL_PLAYER) {
    lightModeService.saveCurrentLightMode(id, CURRENT_LIGHT_MODES.MANUAL_PLAYER, isGroup)

    // 获取当前玩家模式的设置
    const playerData = storageService.getPlayerModeData(id, isGroup, deviceType)
    if (playerData && playerData.presets) {
      // 查找选中的预设
      const selectedPreset = playerData.presets.find(preset => preset.selected)
      if (selectedPreset) {
        // 更新灯光控制条显示和总开关状态
        const rgbwValues = {
          redValue: selectedPreset.redValue || 0,
          greenValue: selectedPreset.greenValue || 0,
          blueValue: selectedPreset.blueValue || 0,
          whiteValue: selectedPreset.whiteValue || 0,
          lightBlueValue: selectedPreset.lightBlueValue || 0,
          royalBlueValue: selectedPreset.royalBlueValue || 0,
          purpleValue: selectedPreset.purpleValue || 0,
          uvValue: selectedPreset.uvValue || 0
        }
        updateByPlayerMode(id, isGroup, rgbwValues, deviceType)
      }
    }
  }
}

/**
 * 公共接口: 重置首页卡片的控制状态 (调用内部函数)
 * @param {string} id - 设备ID或编组ID
 * @param {boolean} isGroup - 是否为编组
 * @param {string} deviceType - 设备类型
 */
function resetHomepageControls(id, isGroup = false, deviceType) {
  console.log(`调用 resetHomepageControls (ID: ${id}, isGroup: ${isGroup}, deviceType: ${deviceType})`)
  _resetRGBWControls(id, isGroup, deviceType);
}

module.exports = {
  LIGHT_MODE_TYPES,
  CURRENT_LIGHT_MODES,
  MODE_CODE_TO_INDEX,
  SHORTCUT_MODE_RGBW_VALUES,
  isManualMode,
  isAutoMode,
  getCurrentLightMode,
  isManualShortcutMode,
  isManualPlayerMode,
  setManualMode,
  setManualShortcutMode,
  setManualPlayerMode,
  setAutoMode,
  updateTotalSwitchState,
  updateTotalSwitchByShortcutBrightness,
  updateTotalSwitchByPlayerRgbw,
  updateByShortcutMode,
  updateByPlayerMode,
  handleShortcutModeMqttData,
  handlePlayerModeMqttData,
  handleManualModeActivation,
  convertToPercentage,
  getBaseLength,
  updateManualModeRgbwCache,
  resetHomepageControls,
}
